home *** CD-ROM | disk | FTP | other *** search
/ Champak 143 / (Vol 143) Nov 15 2011.iso / Games / aqua_cubes.swf / scripts / frame_83 / DoAction_5.as < prev    next >
Text File  |  2011-11-15  |  33KB  |  1,244 lines
  1. function setBlock(block, frame)
  2. {
  3.    block.color = frame % MAX_COLOR;
  4.    block.bomb = frame <= MAX_COLOR ? false : true;
  5.    block.gotoAndStop(frame);
  6. }
  7. var BLOCK_WIDTH = 40;
  8. var BLOCK_HEIGHT = 40;
  9. var MIN_BLOCK = 4;
  10. var MAX_COLOR = 9;
  11. ctrl.initialGame = function(row, col)
  12. {
  13.    trace("initialGame");
  14.    board.row = row;
  15.    board.col = col;
  16.    var _loc2_ = undefined;
  17.    _loc2_ = 1;
  18.    var _loc6_ = 1;
  19.    while(_loc6_ <= col)
  20.    {
  21.       var _loc5_ = row;
  22.       while(_loc5_ >= 1)
  23.       {
  24.          var _loc4_ = board.attachMovie("obj_piece","block" + _loc2_,_loc2_);
  25.          _loc4_.no = _loc2_;
  26.          var _loc3_ = new Object();
  27.          _loc3_.row = _loc5_;
  28.          _loc3_.col = _loc6_;
  29.          _loc3_.x = _loc4_._x = (_loc6_ - 1) * BLOCK_WIDTH;
  30.          _loc3_.y = _loc4_._y = (_loc5_ - 1) * BLOCK_HEIGHT;
  31.          _loc2_ = _loc2_ + 1;
  32.          _loc4_.pos = _loc3_;
  33.          _loc4_.onPress = function()
  34.          {
  35.             trace(this + "," + this.color + "," + this.bomb);
  36.             ctrl.startMove(this);
  37.          };
  38.          _loc5_ = _loc5_ - 1;
  39.       }
  40.       _loc6_ = _loc6_ + 1;
  41.    }
  42.    board.createEmptyMovieClip("contCol1",1101);
  43.    board.createEmptyMovieClip("contCol2",1102);
  44.    board.createEmptyMovieClip("contRow1",1103);
  45.    board.createEmptyMovieClip("contRow2",1104);
  46.    var _loc7_ = undefined;
  47.    var _loc8_ = 1;
  48.    while(_loc8_ <= 2)
  49.    {
  50.       _loc7_ = board["contCol" + _loc8_];
  51.       _loc7_._visible = false;
  52.       _loc2_ = 1;
  53.       _loc5_ = 0;
  54.       while(_loc5_ < row)
  55.       {
  56.          _loc4_ = _loc7_.attachMovie("obj_piece","block" + _loc2_,_loc2_);
  57.          _loc2_ = _loc2_ + 1;
  58.          _loc4_._x = 0;
  59.          _loc4_._y = _loc5_ * BLOCK_HEIGHT;
  60.          _loc4_.stop();
  61.          _loc5_ = _loc5_ + 1;
  62.       }
  63.       _loc7_ = board["contRow" + _loc8_];
  64.       _loc7_._visible = false;
  65.       _loc2_ = 1;
  66.       _loc6_ = 0;
  67.       while(_loc6_ < col)
  68.       {
  69.          _loc4_ = _loc7_.attachMovie("obj_piece","block" + _loc2_,_loc2_);
  70.          _loc2_ = _loc2_ + 1;
  71.          _loc4_._x = _loc6_ * BLOCK_WIDTH;
  72.          _loc4_._y = 0;
  73.          _loc4_.stop();
  74.          _loc6_ = _loc6_ + 1;
  75.       }
  76.       _loc8_ = _loc8_ + 1;
  77.    }
  78. };
  79. ctrl.resetGame = function()
  80. {
  81.    hint_start._visible = false;
  82.    hint_target._visible = false;
  83.    delete this.onEnterFrame;
  84.    delete this.onMouseMove;
  85.    delete this.onMouseUp;
  86.    delete this.disposeInfo;
  87.    delete this.moveInfo;
  88.    this.onEnterFrame = function()
  89.    {
  90.       this.checkMove();
  91.       delete this.onEnterFrame;
  92.       trace("movable : " + this.movable);
  93.    };
  94.    combo.gotoAndStop(1);
  95.    board.resetBoard();
  96. };
  97. board.createDisposeAt = function(block)
  98. {
  99.    var _loc3_ = this.dNo;
  100.    var _loc2_ = this.attachMovie("fx_explode","explode" + _loc3_,2000 + _loc3_);
  101.    if(_loc2_)
  102.    {
  103.       this.dNo = this.dNo + 1;
  104.       _loc2_._x = block._x;
  105.       _loc2_._y = block._y;
  106.    }
  107. };
  108. board.createLinkAt = function(block, dir)
  109. {
  110.    var _loc1_ = undefined;
  111.    if(dir == "T")
  112.    {
  113.       _loc1_ = block.attachMovie("linkT","link1",101);
  114.    }
  115.    else if(dir == "B")
  116.    {
  117.       _loc1_ = block.attachMovie("linkB","link2",101);
  118.    }
  119.    return _loc1_;
  120. };
  121. ctrl.randomLink = function()
  122. {
  123.    if(this.moveInfo == undefined && this.disposeInfo == undefined)
  124.    {
  125.       trace("ctrl.randomLink");
  126.       board.randomLink(blocks);
  127.       delete this.linkInfo;
  128.    }
  129.    else
  130.    {
  131.       this.linkInfo = true;
  132.    }
  133. };
  134. board.randomLink = function()
  135. {
  136.    trace("randomLink");
  137.    var _loc4_ = this.getBlocks();
  138.    _loc4_.shift();
  139.    var _loc10_ = 0;
  140.    var _loc5_ = _loc4_.length - 1;
  141.    while(_loc5_ >= 0)
  142.    {
  143.       if(_loc4_[_loc5_].link1)
  144.       {
  145.          _loc10_ = _loc10_ + 1;
  146.       }
  147.       _loc5_ = _loc5_ - 1;
  148.    }
  149.    if(_loc10_ < game.maxObstruct)
  150.    {
  151.       trace("board.randomLink");
  152.       var _loc8_ = false;
  153.       do
  154.       {
  155.          var _loc6_ = Math.floor(Math.random() * _loc4_.length);
  156.          var _loc2_ = _loc4_[_loc6_];
  157.          var _loc7_ = _loc2_.pos.row;
  158.          var _loc9_ = _loc2_.pos.col;
  159.          _loc4_.splice(_loc6_,1);
  160.          if(_loc7_ != this.row)
  161.          {
  162.             var _loc3_ = this.getRealBlock(_loc2_.pos.row + 1,_loc2_.pos.col);
  163.             if(_loc2_.link1 == undefined && _loc2_.link2 == undefined && _loc3_.link1 == undefined && _loc3_.link2 == undefined)
  164.             {
  165.                this.createLinkAt(_loc2_,"T");
  166.                this.createLinkAt(_loc3_,"B");
  167.                _loc2_.link1.linkTo = _loc3_.link2;
  168.                _loc3_.link2.linkTo = _loc2_.link1;
  169.                _loc8_ = true;
  170.             }
  171.          }
  172.       }
  173.       while(!_loc8_ && _loc4_.length > 0);
  174.       
  175.    }
  176. };
  177. board.resetBoard = function()
  178. {
  179.    this.dNo = 0;
  180.    this.backToNormal();
  181.    var i = this.row * this.col;
  182.    while(i > 0)
  183.    {
  184.       with(this["block" + i])
  185.       {
  186.          _x = pos.x;
  187.          _y = pos.y;
  188.       }
  189.       i--;
  190.    }
  191. };
  192. board.backToNormal = function()
  193. {
  194.    this.contCol1._visible = false;
  195.    this.contCol2._visible = false;
  196.    this.contRow1._visible = false;
  197.    this.contRow2._visible = false;
  198.    var _loc2_ = this.grab.pos;
  199.    this.setVisibleLine("C",_loc2_.col,true);
  200.    this.setVisibleLine("R",_loc2_.row,true);
  201. };
  202. board.getRealBlock = function(tr, tc)
  203. {
  204.    return this["block" + ((tc - 1) * this.col + (this.row - tr + 1))];
  205. };
  206. board.setVisibleLine = function(dir, t, vis)
  207. {
  208.    var _loc2_ = function(block)
  209.    {
  210.       block._visible = vis;
  211.    };
  212.    this.traverse(dir,t,_loc2_);
  213. };
  214. board.traverse = function(dir, t, action)
  215. {
  216.    switch(dir)
  217.    {
  218.       case "R":
  219.          var _loc3_ = 1;
  220.          while(_loc3_ <= this.col)
  221.          {
  222.             action.apply(action,[this.getRealBlock(t,_loc3_)]);
  223.             _loc3_ = _loc3_ + 1;
  224.          }
  225.          break;
  226.       case "C":
  227.          var _loc2_ = 1;
  228.          while(_loc2_ <= this.row)
  229.          {
  230.             action.apply(action,[this.getRealBlock(_loc2_,t)]);
  231.             _loc2_ = _loc2_ + 1;
  232.          }
  233.    }
  234. };
  235. board.randomBoard = function()
  236. {
  237.    var _loc7_ = new Array(this.row * this.col + 1);
  238.    var _loc3_ = 1;
  239.    while(_loc3_ < _loc7_.length)
  240.    {
  241.       var _loc6_ = false;
  242.       do
  243.       {
  244.          var _loc5_ = 1 + Math.floor(Math.random() * game.playColor);
  245.          _loc7_[_loc3_] = {color:_loc5_};
  246.          var _loc4_ = this.findSmallAdjacent(_loc3_,_loc7_);
  247.          if(_loc4_ == undefined || _loc4_.length < MIN_BLOCK)
  248.          {
  249.             _loc6_ = true;
  250.             var _loc2_ = this["block" + _loc3_];
  251.             setBlock(_loc2_,_loc5_);
  252.             _loc2_.link1.removeMovieClip();
  253.             _loc2_.link2.removeMovieClip();
  254.          }
  255.       }
  256.       while(!_loc6_);
  257.       
  258.       _loc3_ = _loc3_ + 1;
  259.    }
  260. };
  261. board.getHint = function()
  262. {
  263.    var _loc8_ = 1;
  264.    while(_loc8_ <= this.row)
  265.    {
  266.       var _loc5_ = 1;
  267.       while(_loc5_ <= this.col)
  268.       {
  269.          var _loc3_ = this.getRealBlock(_loc8_,_loc5_);
  270.          var _loc6_ = undefined;
  271.          var _loc2_ = undefined;
  272.          if(!this.getLock(_loc3_).lockRow)
  273.          {
  274.             var _loc7_ = 1;
  275.             while(_loc7_ <= this.row)
  276.             {
  277.                var _loc10_ = _loc7_ - _loc8_;
  278.                if(_loc10_ != 0)
  279.                {
  280.                   _loc6_ = this.prepareAdjacent(_loc3_,"R",_loc10_).blocks;
  281.                   var _loc12_ = new Array();
  282.                   var _loc4_ = this.col;
  283.                   while(_loc4_ >= 1)
  284.                   {
  285.                      _loc2_ = this.findSmallAdjacent(this.getRealBlock(_loc8_,_loc4_).no,_loc6_);
  286.                      if(_loc2_ && _loc2_.length >= MIN_BLOCK)
  287.                      {
  288.                         return {dir:"R",step:_loc10_,no:_loc3_.no};
  289.                      }
  290.                      _loc4_ = _loc4_ - 1;
  291.                   }
  292.                }
  293.                _loc7_ = _loc7_ + 1;
  294.             }
  295.          }
  296.          _loc7_ = 1;
  297.          while(_loc7_ <= this.col)
  298.          {
  299.             _loc10_ = _loc7_ - _loc5_;
  300.             if(_loc10_ != 0)
  301.             {
  302.                _loc6_ = this.prepareAdjacent(_loc3_,"C",_loc10_).blocks;
  303.                _loc12_ = new Array();
  304.                _loc4_ = this.row;
  305.                while(_loc4_ >= 1)
  306.                {
  307.                   _loc2_ = this.findSmallAdjacent(this.getRealBlock(_loc4_,_loc5_).no,_loc6_);
  308.                   if(_loc2_ && _loc2_.length >= MIN_BLOCK)
  309.                   {
  310.                      return {dir:"C",step:_loc10_,no:_loc3_.no};
  311.                   }
  312.                   _loc4_ = _loc4_ - 1;
  313.                }
  314.             }
  315.             _loc7_ = _loc7_ + 1;
  316.          }
  317.          _loc5_ = _loc5_ + 1;
  318.       }
  319.       _loc8_ = _loc8_ + 1;
  320.    }
  321. };
  322. board.getLock = function(block)
  323. {
  324.    var _loc6_ = new Object();
  325.    var _loc5_ = undefined;
  326.    _loc5_ = block.pos.row;
  327.    var _loc3_ = 1;
  328.    while(_loc3_ <= this.col)
  329.    {
  330.       var _loc4_ = this.getRealBlock(_loc5_,_loc3_);
  331.       if(_loc4_.link1 || _loc4_.link2)
  332.       {
  333.          _loc6_.lockRow = true;
  334.          break;
  335.       }
  336.       _loc3_ = _loc3_ + 1;
  337.    }
  338.    _loc5_ = block.pos.col;
  339.    var _loc2_ = 1;
  340.    while(_loc2_ <= this.row)
  341.    {
  342.       if(this.getRealBlock(_loc2_,_loc5_).linkCol)
  343.       {
  344.          _loc6_.lockCol = true;
  345.          break;
  346.       }
  347.       _loc2_ = _loc2_ + 1;
  348.    }
  349.    return _loc6_;
  350. };
  351. board.prepareAdjacent = function(block, dir, step)
  352. {
  353.    var _loc4_ = undefined;
  354.    switch(dir)
  355.    {
  356.       case "R":
  357.          _loc4_ = this.row - block.pos.row + 1;
  358.          break;
  359.       case "C":
  360.          _loc4_ = block.pos.col;
  361.    }
  362.    var _loc5_ = this.getBlocks();
  363.    var _loc6_ = this.getRollChanged(_loc5_,dir,_loc4_,step);
  364.    var _loc2_ = _loc6_.length - 1;
  365.    while(_loc2_ >= 0)
  366.    {
  367.       var _loc3_ = _loc6_[_loc2_];
  368.       _loc5_[_loc3_.no] = _loc3_.value;
  369.       _loc2_ = _loc2_ - 1;
  370.    }
  371.    return {blocks:_loc5_,roll:_loc6_};
  372. };
  373. board.getAdjacent = function(find, blocks)
  374. {
  375.    var _loc4_ = new Array();
  376.    var _loc6_ = undefined;
  377.    while(_loc6_ = find.pop())
  378.    {
  379.       var _loc5_ = undefined;
  380.       var _loc3_ = _loc4_.length - 1;
  381.       while(_loc3_ >= 0)
  382.       {
  383.          var _loc2_ = _loc4_[_loc3_].length - 1;
  384.          while(_loc2_ >= 0)
  385.          {
  386.             if(_loc4_[_loc3_][_loc2_] == _loc6_)
  387.             {
  388.                _loc5_ = true;
  389.                break;
  390.             }
  391.             _loc2_ = _loc2_ - 1;
  392.          }
  393.          if(_loc5_)
  394.          {
  395.             break;
  396.          }
  397.          _loc3_ = _loc3_ - 1;
  398.       }
  399.       if(!_loc5_)
  400.       {
  401.          var _loc7_ = this.findAdjacent(_loc6_,blocks);
  402.          if(_loc7_ && _loc7_.length >= MIN_BLOCK)
  403.          {
  404.             _loc4_.push(_loc7_);
  405.          }
  406.       }
  407.    }
  408.    return _loc4_;
  409. };
  410. board.blazeTheBomb = function(res)
  411. {
  412.    var _loc9_ = this.row;
  413.    var _loc14_ = this.col;
  414.    var _loc10_ = 0;
  415.    while(_loc10_ < res.length)
  416.    {
  417.       var _loc4_ = res[_loc10_];
  418.       if(this["block" + _loc4_].bomb)
  419.       {
  420.          var _loc11_ = new Sound();
  421.          _loc11_.attachSound("sfx_explode01");
  422.          _loc11_.start();
  423.          var _loc6_ = [_loc4_ - _loc9_,_loc4_ + _loc9_];
  424.          var _loc12_ = _loc4_ % _loc9_;
  425.          if(_loc12_ != 0)
  426.          {
  427.             _loc6_ = _loc6_.concat([_loc4_ - _loc9_ + 1,_loc4_ + 1,_loc4_ + _loc9_ + 1]);
  428.          }
  429.          if(_loc12_ != 1)
  430.          {
  431.             _loc6_ = _loc6_.concat([_loc4_ - _loc9_ - 1,_loc4_ - 1,_loc4_ + _loc9_ - 1]);
  432.          }
  433.          var _loc13_ = _loc9_ * _loc14_;
  434.          var _loc7_ = 0;
  435.          while(_loc7_ < _loc6_.length)
  436.          {
  437.             var _loc3_ = _loc6_[_loc7_];
  438.             if(_loc3_ >= 1 && _loc3_ <= _loc13_)
  439.             {
  440.                var _loc8_ = false;
  441.                var _loc2_ = 0;
  442.                while(_loc2_ < res.length)
  443.                {
  444.                   if(res[_loc2_] == _loc3_)
  445.                   {
  446.                      _loc8_ = true;
  447.                      break;
  448.                   }
  449.                   _loc2_ = _loc2_ + 1;
  450.                }
  451.                if(!_loc8_)
  452.                {
  453.                   res.push(_loc3_);
  454.                }
  455.             }
  456.             _loc7_ = _loc7_ + 1;
  457.          }
  458.       }
  459.       _loc10_ = _loc10_ + 1;
  460.    }
  461.    return res;
  462. };
  463. ctrl.startMove = function(block)
  464. {
  465.    if(_root.gamepause)
  466.    {
  467.       return undefined;
  468.    }
  469.    if(this.moveInfo != undefined)
  470.    {
  471.       return undefined;
  472.    }
  473.    if(this.disposeInfo != undefined)
  474.    {
  475.       return undefined;
  476.    }
  477.    board.grab = block;
  478.    board.bound = block.getBounds(this);
  479.    delete this.lock;
  480.    delete this.lockRow;
  481.    delete this.lockCol;
  482.    var _loc15_ = board.getLock(block);
  483.    this.lockRow = _loc15_.lockRow;
  484.    this.lockCol = _loc15_.lockCol;
  485.    this.onMouseUp = function()
  486.    {
  487.       delete this.onMouseMove;
  488.       delete this.onMouseUp;
  489.       var _loc17_ = this.lock;
  490.       delete this.lock;
  491.       if(_loc17_)
  492.       {
  493.          delete this.moveInfo;
  494.          return undefined;
  495.       }
  496.       var _loc11_ = this.moveInfo;
  497.       if(_loc11_ != undefined)
  498.       {
  499.          var _loc14_ = undefined;
  500.          var _loc9_ = new Array();
  501.          trace(_loc11_.step);
  502.          switch(_loc11_.dir)
  503.          {
  504.             case "R":
  505.                _loc14_ = Math.round(_loc11_.step / BLOCK_WIDTH);
  506.                var _loc10_ = board.grab.pos.row;
  507.                var _loc5_ = board.col;
  508.                while(_loc5_ >= 1)
  509.                {
  510.                   _loc9_.push(board.getRealBlock(_loc10_,_loc5_).no);
  511.                   _loc5_ = _loc5_ - 1;
  512.                }
  513.                break;
  514.             case "C":
  515.                _loc14_ = Math.round(_loc11_.step / BLOCK_HEIGHT);
  516.                _loc10_ = board.grab.pos.col;
  517.                _loc5_ = board.row;
  518.                while(_loc5_ >= 1)
  519.                {
  520.                   _loc9_.push(board.getRealBlock(_loc5_,_loc10_).no);
  521.                   _loc5_ = _loc5_ - 1;
  522.                }
  523.          }
  524.          var _loc13_ = board.prepareAdjacent(board.grab,_loc11_.dir,_loc14_);
  525.          var _loc15_ = _loc13_.blocks;
  526.          var _loc6_ = _loc13_.roll;
  527.          var _loc16_ = board.getAdjacent(_loc9_,_loc15_);
  528.          game.sum = 0;
  529.          var _loc12_ = game.calculate(_loc16_);
  530.          trace("found : " + _loc12_);
  531.          if(_loc12_.length > 0)
  532.          {
  533.             _loc5_ = _loc6_.length - 1;
  534.             while(_loc5_ >= 0)
  535.             {
  536.                var _loc2_ = _loc6_[_loc5_];
  537.                var _loc4_ = board["block" + _loc2_.no];
  538.                setBlock(_loc4_,_loc2_.face);
  539.                if(_loc2_.link1)
  540.                {
  541.                   board.createLinkAt(_loc4_,"T");
  542.                }
  543.                else
  544.                {
  545.                   _loc4_.link1.removeMovieClip();
  546.                }
  547.                if(_loc2_.link2)
  548.                {
  549.                   board.createLinkAt(_loc4_,"B");
  550.                }
  551.                else
  552.                {
  553.                   _loc4_.link2.removeMovieClip();
  554.                }
  555.                _loc5_ = _loc5_ - 1;
  556.             }
  557.             _loc5_ = _loc6_.length - 1;
  558.             while(_loc5_ >= 0)
  559.             {
  560.                var _loc3_ = _loc6_[_loc5_].no;
  561.                _loc4_ = board["block" + _loc3_];
  562.                if(_loc4_.link2)
  563.                {
  564.                   var _loc8_ = _loc3_ % board.row != 0 ? _loc3_ + 1 : _loc3_ - board.row + 1;
  565.                   var _loc7_ = board["block" + _loc8_];
  566.                   _loc4_.link2.linkTo = _loc7_.link1;
  567.                   _loc7_.link1.linkTo = _loc4_.link2;
  568.                }
  569.                _loc5_ = _loc5_ - 1;
  570.             }
  571.             this.moveInfo.step = 0;
  572.             this.onRollBlockBack();
  573.             _loc12_ = board.blazeTheBomb(_loc12_);
  574.             this.disposeBlock(_loc12_);
  575.          }
  576.          else
  577.          {
  578.             this.onEnterFrame = this.onRollBlockBack;
  579.          }
  580.       }
  581.    };
  582.    this.onMouseMove = this.onMoveInBlock;
  583. };
  584. board.findDispose = function(list)
  585. {
  586.    var _loc2_ = this.getBlocks();
  587.    var _loc3_ = this.getAdjacent(list,_loc2_);
  588.    return _loc3_;
  589. };
  590. board.afterDispose = function(list)
  591. {
  592.    this.dNo = 0;
  593.    var _loc7_ = 0;
  594.    while(_loc7_ < list.length)
  595.    {
  596.       var _loc3_ = list[_loc7_];
  597.       var _loc2_ = 1 + Math.floor(Math.random() * game.playColor);
  598.       setBlock(_loc3_,_loc2_);
  599.       _loc7_ = _loc7_ + 1;
  600.    }
  601.    if(Math.floor(Math.random() * 100) < 4)
  602.    {
  603.       _loc7_ = Math.floor(Math.random() * list.length);
  604.       var _loc5_ = list[_loc7_];
  605.       var _loc6_ = _loc5_._currentframe + MAX_COLOR;
  606.       if(_loc6_ <= _loc5_._totalframes)
  607.       {
  608.          setBlock(_loc5_,_loc6_);
  609.       }
  610.    }
  611. };
  612. ctrl.playUnlockSound = function(block)
  613. {
  614.    if(block.link1 || block.link2)
  615.    {
  616.    }
  617. };
  618. ctrl.disposeBlock = function(list)
  619. {
  620.    hint_start._visible = false;
  621.    hint_target._visible = false;
  622.    disposeResult(list);
  623.    list.sort(Array.NUMERIC);
  624.    var _loc17_ = new Array();
  625.    var _loc7_ = 1;
  626.    var _loc3_ = board.row;
  627.    var _loc14_ = undefined;
  628.    var _loc16_ = 0;
  629.    while(_loc16_ < board.col)
  630.    {
  631.       _loc14_ = board["block" + _loc3_];
  632.       var _loc15_ = undefined;
  633.       var _loc6_ = 0;
  634.       while(_loc6_ < list.length)
  635.       {
  636.          if(list[_loc6_] <= _loc3_)
  637.          {
  638.             _loc15_ = _loc6_;
  639.          }
  640.          _loc6_ = _loc6_ + 1;
  641.       }
  642.       if(_loc15_ != undefined)
  643.       {
  644.          var _loc11_ = list.splice(0,_loc15_ + 1);
  645.          trace(">..." + _loc11_);
  646.          _loc6_ = 0;
  647.          while(_loc6_ < _loc11_.length)
  648.          {
  649.             var _loc12_ = board["block" + _loc11_[_loc6_]];
  650.             board.createDisposeAt(_loc12_);
  651.             _loc12_._y = _loc14_._y - BLOCK_HEIGHT;
  652.             _loc12_.dispose = true;
  653.             _loc14_ = _loc12_;
  654.             this.playUnlockSound(_loc12_);
  655.             _loc12_.link1.linkTo.removeMovieClip();
  656.             _loc12_.link1.removeMovieClip();
  657.             _loc12_.link2.linkTo.removeMovieClip();
  658.             _loc12_.link2.removeMovieClip();
  659.             _loc6_ = _loc6_ + 1;
  660.          }
  661.          var _loc10_ = new Array();
  662.          var _loc4_ = _loc7_;
  663.          while(_loc4_ <= _loc3_)
  664.          {
  665.             _loc12_ = board["block" + _loc4_];
  666.             var _loc2_ = new Object();
  667.             _loc2_._y = _loc12_._y;
  668.             _loc2_.no = _loc4_;
  669.             _loc2_.type = _loc12_._currentframe;
  670.             _loc2_.dispose = _loc12_.dispose;
  671.             if(_loc4_ == _loc7_)
  672.             {
  673.                this.playUnlockSound(_loc12_);
  674.                _loc12_.link1.removeMovieClip();
  675.                _loc12_.link1.linkTo.removeMovieClip();
  676.             }
  677.             else if(_loc4_ == _loc3_)
  678.             {
  679.                _loc12_.link2.removeMovieClip();
  680.                _loc12_.link2.linkTo.removeMovieClip();
  681.             }
  682.             _loc2_.link1 = _loc12_.link1 != undefined;
  683.             _loc2_.link2 = _loc12_.link2 != undefined;
  684.             _loc12_.link1.removeMovieClip();
  685.             _loc12_.link2.removeMovieClip();
  686.             _loc10_.push(_loc2_);
  687.             _loc4_ = _loc4_ + 1;
  688.          }
  689.          _loc10_.sortOn("_y",Array.NUMERIC | Array.DESCENDING);
  690.          _loc4_ = _loc7_;
  691.          var _loc9_ = 0;
  692.          while(_loc4_ <= _loc3_)
  693.          {
  694.             _loc12_ = board["block" + _loc4_];
  695.             _loc2_ = _loc10_[_loc9_];
  696.             _loc12_._y = _loc2_._y;
  697.             setBlock(_loc12_,_loc2_.type);
  698.             if(_loc2_.link1)
  699.             {
  700.                board.createLinkAt(_loc12_,"T");
  701.             }
  702.             if(_loc2_.link2)
  703.             {
  704.                board.createLinkAt(_loc12_,"B");
  705.             }
  706.             delete _loc12_.dispose;
  707.             if(_loc2_.dispose)
  708.             {
  709.                _loc17_.push(_loc12_);
  710.             }
  711.             _loc4_;
  712.             _loc4_++;
  713.             _loc9_;
  714.             _loc9_++;
  715.          }
  716.          _loc4_ = _loc7_;
  717.          while(_loc4_ <= _loc3_)
  718.          {
  719.             var _loc5_ = board["block" + _loc4_];
  720.             if(_loc5_.link2)
  721.             {
  722.                var _loc8_ = board["block" + (_loc4_ + 1)];
  723.                _loc5_.link2.linkTo = _loc8_.link1;
  724.                _loc8_.link1.linkTo = _loc5_.link2;
  725.             }
  726.             _loc4_ = _loc4_ + 1;
  727.          }
  728.       }
  729.       _loc16_;
  730.       _loc16_++;
  731.       _loc7_ += board.row;
  732.       _loc3_ += board.row;
  733.    }
  734.    var _loc18_ = new Array();
  735.    var _loc19_ = new Array();
  736.    _loc16_ = board.row * board.col;
  737.    while(_loc16_ >= 1)
  738.    {
  739.       _loc12_ = board["block" + _loc16_];
  740.       if(_loc12_._y != _loc12_.pos.y)
  741.       {
  742.          _loc18_.push(_loc12_);
  743.          _loc19_.push(_loc12_.no);
  744.       }
  745.       _loc16_ = _loc16_ - 1;
  746.    }
  747.    var _loc20_ = new Object();
  748.    _loc20_.list = _loc17_;
  749.    _loc20_.moveBlock = _loc18_;
  750.    _loc20_.findBlock = _loc19_;
  751.    this.disposeInfo = _loc20_;
  752.    this.finish = getTimer() + 500;
  753.    this.onEnterFrame = function()
  754.    {
  755.       if(getTimer() > this.finish)
  756.       {
  757.          delete this.finish;
  758.          board.afterDispose(this.disposeInfo.list);
  759.          this.onEnterFrame = this.onBlockFall;
  760.       }
  761.    };
  762. };
  763. ctrl.checkMove = function()
  764. {
  765.    var _loc2_ = board.getHint();
  766.    this.movable = _loc2_ != undefined;
  767. };
  768. ctrl.onBlockFall = function()
  769. {
  770.    var _loc5_ = this.disposeInfo.moveBlock;
  771.    var _loc4_ = _loc5_.length - 1;
  772.    while(_loc4_ >= 0)
  773.    {
  774.       var _loc3_ = _loc5_[_loc4_];
  775.       _loc3_._y += Math.min(_loc3_.pos.y - _loc3_._y,20);
  776.       if(_loc3_._y == _loc3_.pos.y)
  777.       {
  778.          _loc5_.splice(_loc4_,1);
  779.       }
  780.       _loc4_ = _loc4_ - 1;
  781.    }
  782.    if(_loc5_.length == 0)
  783.    {
  784.       this.finish = getTimer() + 100;
  785.       this.onEnterFrame = function()
  786.       {
  787.          if(getTimer() > this.finish)
  788.          {
  789.             delete this.finish;
  790.             this.onEnterFrame = function()
  791.             {
  792.                if(_root.gamepause)
  793.                {
  794.                   return undefined;
  795.                }
  796.                var _loc4_ = board.findDispose(this.disposeInfo.findBlock);
  797.                var _loc3_ = game.calculate(_loc4_);
  798.                if(_loc3_.length > 0)
  799.                {
  800.                   _loc3_ = board.blazeTheBomb(_loc3_);
  801.                   this.disposeBlock(_loc3_);
  802.                }
  803.                else
  804.                {
  805.                   delete this.disposeInfo;
  806.                   delete this.onEnterFrame;
  807.                   if(this.linkInfo)
  808.                   {
  809.                      ctrl.randomLink();
  810.                   }
  811.                   this.checkMove();
  812.                   combo.gotoAndStop(1);
  813.                }
  814.             };
  815.          }
  816.       };
  817.    }
  818. };
  819. game.calculate = function(adj)
  820. {
  821.    var _loc4_ = new Array();
  822.    var _loc6_ = 0;
  823.    var _loc7_ = 0;
  824.    var _loc3_ = 0;
  825.    while(_loc3_ < adj.length)
  826.    {
  827.       _loc4_ = _loc4_.concat(adj[_loc3_]);
  828.       var _loc2_ = adj[_loc3_].length;
  829.       game.sum += _loc2_;
  830.       _loc6_ = Math.max(_loc2_,_loc6_);
  831.       if(_loc2_ > 6)
  832.       {
  833.          _loc7_ += (_loc2_ - 6) * 100;
  834.       }
  835.       _loc3_ = _loc3_ + 1;
  836.    }
  837.    if(_loc4_.length > 0)
  838.    {
  839.       if(_root.gamemode == "story")
  840.       {
  841.          trace("add score story");
  842.          _root.score += _loc4_.length * 10 + _loc7_;
  843.       }
  844.       if(_root.gamemode == "survival")
  845.       {
  846.          trace("add score survival");
  847.          _root.score += (MAX_COLOR + _loc4_.length + _loc7_) * 15;
  848.       }
  849.    }
  850.    if(game.sum >= 11)
  851.    {
  852.       combo.gotoAndStop(4);
  853.    }
  854.    else if(game.sum >= 9)
  855.    {
  856.       combo.gotoAndStop(3);
  857.    }
  858.    else if(game.sum >= 7)
  859.    {
  860.       combo.gotoAndStop(2);
  861.    }
  862.    combo.cmb.gotoAndPlay(1);
  863.    return _loc4_;
  864. };
  865. ctrl.onRollBlockBack = function()
  866. {
  867.    var _loc2_ = this.moveInfo;
  868.    if(_loc2_.step == 0)
  869.    {
  870.       board.backToNormal();
  871.       delete this.moveInfo;
  872.       delete this.onEnterFrame;
  873.    }
  874.    else
  875.    {
  876.       _loc2_.step *= 0.8;
  877.       if(Math.abs(_loc2_.step) < 1)
  878.       {
  879.          _loc2_.step = 0;
  880.       }
  881.       this.updateMove();
  882.    }
  883. };
  884. ctrl.getDirection = function(bound, x, y)
  885. {
  886.    var _loc3_ = bound;
  887.    var _loc7_ = undefined;
  888.    var _loc6_ = undefined;
  889.    var _loc5_ = undefined;
  890.    var _loc4_ = undefined;
  891.    _loc7_ = _loc3_.xMin - x;
  892.    _loc6_ = x - _loc3_.xMax;
  893.    _loc5_ = _loc3_.yMin - y;
  894.    _loc4_ = y - _loc3_.yMax;
  895.    var _loc2_ = Math.max(Math.max(_loc7_,_loc6_),Math.max(_loc5_,_loc4_));
  896.    if(_loc2_ > 0)
  897.    {
  898.       var _loc1_ = new Object();
  899.       if(_loc2_ == _loc7_)
  900.       {
  901.          _loc1_.dir = "R";
  902.          _loc1_.step = - _loc2_;
  903.       }
  904.       else if(_loc2_ == _loc6_)
  905.       {
  906.          _loc1_.dir = "R";
  907.          _loc1_.step = _loc2_;
  908.       }
  909.       else if(_loc2_ == _loc5_)
  910.       {
  911.          _loc1_.dir = "C";
  912.          _loc1_.step = - _loc2_;
  913.       }
  914.       else if(_loc2_ == _loc4_)
  915.       {
  916.          _loc1_.dir = "C";
  917.          _loc1_.step = _loc2_;
  918.       }
  919.       return _loc1_;
  920.    }
  921. };
  922. ctrl.onMoveInBlock = function()
  923. {
  924.    delete this.lock;
  925.    var _loc5_ = this.getDirection(board.bound,this._xmouse,this._ymouse);
  926.    if(_loc5_ != undefined)
  927.    {
  928.       this.moveInfo = _loc5_;
  929.       var _loc4_ = board.grab.pos;
  930.       var _loc6_ = undefined;
  931.       var _loc3_ = undefined;
  932.       var _loc2_ = undefined;
  933.       var lock;
  934.       switch(_loc5_.dir)
  935.       {
  936.          case "R":
  937.             _loc3_ = board.contRow1;
  938.             _loc3_._x = 0;
  939.             _loc3_._y = _loc4_.y;
  940.             _loc2_ = board.contRow2;
  941.             _loc2_._x = 0;
  942.             _loc2_._y = _loc4_.y;
  943.             _loc6_ = _loc4_.row;
  944.             if(this.lockRow)
  945.             {
  946.                lock = true;
  947.             }
  948.             break;
  949.          case "C":
  950.             _loc3_ = board.contCol1;
  951.             _loc3_._x = _loc4_.x;
  952.             _loc3_._y = 0;
  953.             _loc2_ = board.contCol2;
  954.             _loc2_._x = _loc4_.x;
  955.             _loc2_._y = 0;
  956.             _loc6_ = _loc4_.col;
  957.             if(this.lockCol)
  958.             {
  959.                lock = true;
  960.             }
  961.       }
  962.       this.lock = lock == true;
  963.       trace(this.lock);
  964.       if(lock)
  965.       {
  966.          trace("lock.............");
  967.       }
  968.       else
  969.       {
  970.          board.setVisibleLine(_loc5_.dir,_loc6_,false);
  971.          this.setContainerLine(_loc5_.dir,_loc6_,[_loc3_,_loc2_]);
  972.          _loc3_._visible = true;
  973.          _loc2_._visible = true;
  974.          this.onMouseMove = this.onMoveOutBlock;
  975.       }
  976.    }
  977.    else
  978.    {
  979.       board.backToNormal();
  980.       delete this.moveInfo;
  981.    }
  982. };
  983. ctrl.setContainerLine = function(dir, t, cont)
  984. {
  985.    var _loc7_ = undefined;
  986.    var _loc2_ = undefined;
  987.    _loc7_ = dir != "R" ? board.row : board.col;
  988.    var _loc3_ = 1;
  989.    while(_loc3_ <= _loc7_)
  990.    {
  991.       if(dir == "R")
  992.       {
  993.          _loc2_ = board.getRealBlock(t,_loc3_);
  994.       }
  995.       else
  996.       {
  997.          _loc2_ = board.getRealBlock(_loc3_,t);
  998.       }
  999.       for(var _loc6_ in cont)
  1000.       {
  1001.          var _loc1_ = cont[_loc6_]["block" + _loc3_];
  1002.          setBlock(_loc1_,_loc2_._currentframe);
  1003.          if(_loc2_.link1)
  1004.          {
  1005.             board.createLinkAt(_loc1_,"T");
  1006.          }
  1007.          else
  1008.          {
  1009.             _loc1_.link1.removeMovieClip();
  1010.          }
  1011.          if(_loc2_.link2)
  1012.          {
  1013.             board.createLinkAt(_loc1_,"B");
  1014.          }
  1015.          else
  1016.          {
  1017.             _loc1_.link2.removeMovieClip();
  1018.          }
  1019.       }
  1020.       _loc3_ = _loc3_ + 1;
  1021.    }
  1022. };
  1023. ctrl.onMoveOutBlock = function()
  1024. {
  1025.    var _loc2_ = this.getDirection(board.bound,this._xmouse,this._ymouse);
  1026.    if(_loc2_ != undefined)
  1027.    {
  1028.       switch(_loc2_.dir)
  1029.       {
  1030.          case "C":
  1031.             _loc2_.step += (_loc2_.step <= 0 ? -1 : 1) * BLOCK_HEIGHT / 2;
  1032.             break;
  1033.          case "R":
  1034.             _loc2_.step += (_loc2_.step <= 0 ? -1 : 1) * BLOCK_WIDTH / 2;
  1035.       }
  1036.       this.moveInfo = _loc2_;
  1037.       this.updateMove();
  1038.    }
  1039.    else
  1040.    {
  1041.       trace("come back");
  1042.       this.onMouseMove = this.onMoveInBlock;
  1043.    }
  1044. };
  1045. ctrl.updateMove = function()
  1046. {
  1047.    var _loc3_ = this.moveInfo.step;
  1048.    var _loc4_ = board.grab;
  1049.    var _loc2_ = undefined;
  1050.    switch(this.moveInfo.dir)
  1051.    {
  1052.       case "C":
  1053.          _loc2_ = board.contCol1;
  1054.          _loc2_._y = _loc3_ % _loc2_._height;
  1055.          board.contCol2._y = _loc2_._y + (_loc3_ <= 0 ? 1 : -1) * _loc2_._height;
  1056.          break;
  1057.       case "R":
  1058.          _loc2_ = board.contRow1;
  1059.          _loc2_._x = _loc3_ % _loc2_._width;
  1060.          board.contRow2._x = _loc2_._x + (_loc3_ <= 0 ? 1 : -1) * _loc2_._width;
  1061.    }
  1062. };
  1063. board.initialAdjacent = function()
  1064. {
  1065.    var _loc0_ = null;
  1066.    var _loc3_ = this.adjData = new Object();
  1067.    _loc3_.head = new Array();
  1068.    _loc3_.bottom = new Array();
  1069.    var _loc5_ = undefined;
  1070.    var _loc4_ = undefined;
  1071.    _loc5_ = this.row;
  1072.    _loc4_ = 1;
  1073.    var _loc2_ = 0;
  1074.    while(_loc2_ < this.col)
  1075.    {
  1076.       _loc3_.head[_loc2_] = _loc5_;
  1077.       _loc3_.bottom[_loc2_] = _loc4_;
  1078.       _loc5_ += this.row;
  1079.       _loc4_ += this.row;
  1080.       _loc2_ = _loc2_ + 1;
  1081.    }
  1082. };
  1083. board.getBlocks = function()
  1084. {
  1085.    var _loc4_ = new Array(this.row * this.col + 1);
  1086.    var _loc2_ = _loc4_.length - 1;
  1087.    while(_loc2_ > 0)
  1088.    {
  1089.       var _loc3_ = this["block" + _loc2_];
  1090.       _loc4_[_loc2_] = _loc3_;
  1091.       _loc2_ = _loc2_ - 1;
  1092.    }
  1093.    return _loc4_;
  1094. };
  1095. board.getRollChanged = function(blocks, dir, line, step)
  1096. {
  1097.    var _loc7_ = undefined;
  1098.    var _loc6_ = undefined;
  1099.    var _loc5_ = undefined;
  1100.    switch(dir)
  1101.    {
  1102.       case "R":
  1103.          _loc7_ = line;
  1104.          _loc6_ = this.row;
  1105.          _loc5_ = this.row;
  1106.          break;
  1107.       case "C":
  1108.          _loc7_ = (line - 1) * this.row + 1;
  1109.          _loc6_ = 1;
  1110.          _loc5_ = this.col;
  1111.          step = - step;
  1112.    }
  1113.    var _loc4_ = new Array(_loc5_);
  1114.    step %= _loc5_;
  1115.    var _loc2_ = 0;
  1116.    while(_loc2_ < _loc5_)
  1117.    {
  1118.       _loc4_[_loc2_] = blocks[_loc7_ + _loc6_ * _loc2_];
  1119.       _loc2_ = _loc2_ + 1;
  1120.    }
  1121.    var _loc10_ = undefined;
  1122.    if(step > 0)
  1123.    {
  1124.       _loc10_ = _loc4_.splice(- step);
  1125.       _loc4_ = _loc10_.concat(_loc4_);
  1126.    }
  1127.    else
  1128.    {
  1129.       _loc10_ = _loc4_.splice(0,Math.abs(step));
  1130.       _loc4_ = _loc4_.concat(_loc10_);
  1131.    }
  1132.    _loc2_ = 0;
  1133.    while(_loc2_ < _loc5_)
  1134.    {
  1135.       var _loc3_ = new Object();
  1136.       _loc3_.no = _loc7_ + _loc6_ * _loc2_;
  1137.       _loc3_.value = _loc4_[_loc2_];
  1138.       _loc3_.face = _loc4_[_loc2_]._currentframe;
  1139.       _loc3_.link1 = _loc4_[_loc2_].link1 != undefined;
  1140.       _loc3_.link2 = _loc4_[_loc2_].link2 != undefined;
  1141.       _loc4_[_loc2_] = _loc3_;
  1142.       _loc2_ = _loc2_ + 1;
  1143.    }
  1144.    return _loc4_;
  1145. };
  1146. board.findSmallAdjacent = function(numba, blocks)
  1147. {
  1148.    return this.findAdjacent(numba,blocks,MIN_BLOCK);
  1149. };
  1150. board.findAdjacent = function(numba, blocks, atleast)
  1151. {
  1152.    if(this.adjData == undefined)
  1153.    {
  1154.       this.initialAdjacent();
  1155.    }
  1156.    var _loc0_ = null;
  1157.    var _loc2_ = this.adjFinder = new Object();
  1158.    _loc2_.allBlock = blocks;
  1159.    _loc2_.result = [numba];
  1160.    _loc2_.c = 0;
  1161.    _loc2_.find = _loc2_.allBlock[numba].color;
  1162.    atleast = Number(atleast);
  1163.    if(!isNaN(atleast) && atleast > 1)
  1164.    {
  1165.       _loc2_.atleast = atleast;
  1166.    }
  1167.    this.findAdjacent2(numba);
  1168.    return _loc2_.result.length <= 1 ? undefined : _loc2_.result;
  1169. };
  1170. board.findAdjacent2 = function(numba)
  1171. {
  1172.    var _loc5_ = 0;
  1173.    var _loc7_ = 0;
  1174.    var _loc2_ = 0;
  1175.    while(_loc2_ < this.col)
  1176.    {
  1177.       if(numba == this.adjData.head[_loc2_])
  1178.       {
  1179.          _loc7_ = 1;
  1180.          break;
  1181.       }
  1182.       if(numba == this.adjData.bottom[_loc2_])
  1183.       {
  1184.          _loc5_ = 1;
  1185.          break;
  1186.       }
  1187.       _loc2_ = _loc2_ + 1;
  1188.    }
  1189.    var _loc6_ = this.adjFinder.result;
  1190.    var _loc8_ = this.adjFinder.allBlock;
  1191.    var _loc10_ = this.adjFinder.find;
  1192.    var _loc3_ = undefined;
  1193.    var _loc9_ = _loc8_.length - 1;
  1194.    _loc3_ = numba + 1;
  1195.    if(_loc3_ >= 1 && _loc3_ <= _loc9_ && _loc10_ == _loc8_[_loc3_].color && _loc7_ != 1 && this.isAdjacent(_loc3_))
  1196.    {
  1197.       _loc6_.push(_loc3_);
  1198.    }
  1199.    _loc3_ = numba + this.row;
  1200.    if(_loc3_ >= 1 && _loc3_ <= _loc9_ && _loc10_ == _loc8_[_loc3_].color && this.isAdjacent(_loc3_))
  1201.    {
  1202.       _loc6_.push(_loc3_);
  1203.    }
  1204.    _loc3_ = numba - 1;
  1205.    if(_loc3_ >= 1 && _loc3_ <= _loc9_ && _loc10_ == _loc8_[_loc3_].color && _loc5_ != 1 && this.isAdjacent(_loc3_))
  1206.    {
  1207.       _loc6_.push(_loc3_);
  1208.    }
  1209.    _loc3_ = numba - this.row;
  1210.    if(_loc3_ >= 1 && _loc3_ <= _loc9_ && _loc10_ == _loc8_[_loc3_].color && this.isAdjacent(_loc3_))
  1211.    {
  1212.       _loc6_.push(_loc3_);
  1213.    }
  1214.    this.adjFinder.c = this.adjFinder.c + 1;
  1215.    if(this.adjFinder.atleast && _loc6_.length >= this.adjFinder.atleast)
  1216.    {
  1217.       return undefined;
  1218.    }
  1219.    if(this.adjFinder.c != _loc6_.length)
  1220.    {
  1221.       this.findAdjacent2(_loc6_[this.adjFinder.c]);
  1222.    }
  1223. };
  1224. board.isAdjacent = function(numba)
  1225. {
  1226.    var _loc4_ = 1;
  1227.    var _loc3_ = this.adjFinder.result;
  1228.    var _loc2_ = 0;
  1229.    while(_loc2_ < _loc3_.length)
  1230.    {
  1231.       if(_loc3_[_loc2_] == numba)
  1232.       {
  1233.          _loc4_ = 0;
  1234.          break;
  1235.       }
  1236.       _loc2_ = _loc2_ + 1;
  1237.    }
  1238.    if(_loc4_ == 1)
  1239.    {
  1240.       return true;
  1241.    }
  1242.    return false;
  1243. };
  1244.